#ifndef Magnum_ShaderTools_AnyConverter_h
#define Magnum_ShaderTools_AnyConverter_h
/*
    This file is part of Magnum.

    Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
                2020, 2021, 2022, 2023, 2024, 2025
              Vladimír Vondruš <mosra@centrum.cz>

    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included
    in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
*/

/** @file
 * @brief Class @ref Magnum::ShaderTools::AnyConverter
 * @m_since_latest
 */

#include "Magnum/ShaderTools/AbstractConverter.h"
#include "MagnumPlugins/AnyShaderConverter/configure.h"

#ifndef DOXYGEN_GENERATING_OUTPUT
#ifndef MAGNUM_ANYSHADERCONVERTER_BUILD_STATIC
    #ifdef AnyShaderConverter_EXPORTS
        #define MAGNUM_ANYSHADERCONVERTER_EXPORT CORRADE_VISIBILITY_EXPORT
    #else
        #define MAGNUM_ANYSHADERCONVERTER_EXPORT CORRADE_VISIBILITY_IMPORT
    #endif
#else
    #define MAGNUM_ANYSHADERCONVERTER_EXPORT CORRADE_VISIBILITY_STATIC
#endif
#define MAGNUM_ANYSHADERCONVERTER_LOCAL CORRADE_VISIBILITY_LOCAL
#else
#define MAGNUM_ANYSHADERCONVERTER_EXPORT
#define MAGNUM_ANYSHADERCONVERTER_LOCAL
#endif

namespace Magnum { namespace ShaderTools {

/**
@brief Any shader converter plugin
@m_since_latest

@m_keywords{AnyShaderConverter}

Loads a plugin corresponding to a format either explicitly set using
@ref setInputFormat() / @ref setOutputFormat() or detected based on input /
output file extension plugin and then tries to either validate or convert the
file with it. These formats are detected based on extension:

-   GLSL (`*.glsl`, `*.vert`, `*.frag`, `*.geom`, `*.comp`, `*.tesc`, `*.tese`,
    `*.rgen`, `*.rint`, `*.rahit`, `*.rchit`, `*.rmiss`, `*.rcall`, `*.mesh`,
    `*.task`)
-   SPIR-V (`*.spv`)
-   SPIR-V Assembly (`*.spvasm`, `*.asm.vert`, ..., `*.asm.task`)

Supported validation scenarios:

-   GLSL, validated with any plugin that provides `GlslShaderConverter`
-   SPIR-V, validated with any plugin that provides `SpirvShaderConverter`
-   SPIR-V Assembly, validated with any plugin that provides
    `SpirvAssemblyShaderConverter`

Supported conversion paths:

-   GLSL to SPIR-V, converted with any plugin that provides
    `GlslToSpirvShaderConverter`
-   SPIR-V to SPIR-V, converted with any plugin that provides
    `SpirvShaderConverter`
-   SPIR-V to SPIR-V Assembly, converted with any plugin that provides
    `SpirvToSpirvAssemblyShaderConverter`
-   SPIR-V Assembly to SPIR-V, converted with any plugin that provides
    `SpirvAssemblyToSpirvShaderConverter`
-   SPIR-V Assembly to SPIR-V Assembly, converted with any plugin that provides
    `SpirvAssemblyShaderConverter`

There's format detection based on file contents, so the plugin has to either
operate on files or @ref setInputFormat() / @ref setOutputFormat() has to be
explicitly set.

@section ShaderTools-AnyConverter-usage Usage

@m_class{m-note m-success}

@par
    This class is a plugin that's meant to be dynamically loaded and used
    through the base @ref AbstractConverter interface. See its documentation
    for introduction and usage examples.

This plugin depends on the @ref ShaderTools library and is built if
`MAGNUM_WITH_ANYSHADERCONVERTER` is enabled when building Magnum. To use as a
dynamic plugin, load @cpp "AnyShaderConverter" @ce via
@ref Corrade::PluginManager::Manager.

Additionally, if you're using Magnum as a CMake subproject, do the following:

@code{.cmake}
set(MAGNUM_WITH_ANYSHADERCONVERTER ON CACHE BOOL "" FORCE)
add_subdirectory(magnum EXCLUDE_FROM_ALL)

# So the dynamically loaded plugin gets built implicitly
add_dependencies(your-app Magnum::AnyShaderConverter)
@endcode

To use as a static plugin or as a dependency of another plugin with CMake, you
need to request the `AnyShaderConverter` component of the `Magnum` package and
link to the `Magnum::AnyShaderConverter` target:

@code{.cmake}
find_package(Magnum REQUIRED AnyShaderConverter)

# ...
target_link_libraries(your-app PRIVATE Magnum::AnyShaderConverter)
@endcode

See @ref building, @ref cmake and @ref plugins for more information.

@section ShaderTools-AnyConverter-proxy Interface proxying and option propagation

On a call to @ref validateFile() / @ref validateData(), @ref convertFileToFile()
/ @ref convertFileToData() / @ref convertDataToData(), an input/output file
format is detected from either the extensions or taken from the
@ref setInputFormat() and @ref setOutputFormat() calls and a corresponding
plugin is loaded. After that, everything set via @ref setFlags(),
@ref setInputFormat(), @ref setOutputFormat(), @ref setDefinitions(),
@ref setDebugInfoLevel(), @ref setOptimizationLevel() is propagated to the
concrete implementation, with an error emitted in case the target plugin
doesn't support given feature. Options set through @ref configuration() are
propagated as well, with just a warning emitted in case given option is not
present in the default configuration of the target plugin.

The output of the @ref validateFile() / @ref validateData(),
@ref convertFileToFile() / @ref convertFileToData() / @ref convertDataToData()
function called on the concrete implementation is then proxied back.

Besides delegating the flags, the @ref AnyConverter itself recognizes
@ref ConverterFlag::Verbose, printing info about the concrete plugin being used
when the flag is enabled. @ref ConverterFlag::Quiet is recognized as well and
causes all warnings to be suppressed.
*/
class MAGNUM_ANYSHADERCONVERTER_EXPORT AnyConverter: public AbstractConverter {
    public:
        /** @brief Constructor with access to plugin manager */
        explicit AnyConverter(PluginManager::Manager<AbstractConverter>& manager);

        /** @brief Plugin manager constructor */
        explicit AnyConverter(PluginManager::AbstractManager& manager, const Containers::StringView& plugin);

        ~AnyConverter();

    private:
        MAGNUM_ANYSHADERCONVERTER_LOCAL ConverterFeatures doFeatures() const override;

        MAGNUM_ANYSHADERCONVERTER_LOCAL void doSetInputFormat(Format, Containers::StringView version) override;
        MAGNUM_ANYSHADERCONVERTER_LOCAL void doSetOutputFormat(Format, Containers::StringView version) override;
        MAGNUM_ANYSHADERCONVERTER_LOCAL void doSetDefinitions(Containers::ArrayView<const Containers::Pair<Containers::StringView, Containers::StringView>> definitions) override;
        MAGNUM_ANYSHADERCONVERTER_LOCAL void doSetDebugInfoLevel(Containers::StringView level) override;
        MAGNUM_ANYSHADERCONVERTER_LOCAL void doSetOptimizationLevel(Containers::StringView level) override;

        MAGNUM_ANYSHADERCONVERTER_LOCAL Containers::Pair<bool, Containers::String> doValidateFile(Stage stage, Containers::StringView filename) override;
        MAGNUM_ANYSHADERCONVERTER_LOCAL Containers::Pair<bool, Containers::String> doValidateData(Stage stage, Containers::ArrayView<const char> data) override;
        MAGNUM_ANYSHADERCONVERTER_LOCAL bool doConvertFileToFile(Stage stage, Containers::StringView from, Containers::StringView to) override;
        MAGNUM_ANYSHADERCONVERTER_LOCAL Containers::Optional<Containers::Array<char>> doConvertFileToData(Magnum::ShaderTools::Stage stage, Containers::StringView filename) override;
        MAGNUM_ANYSHADERCONVERTER_LOCAL Containers::Optional<Containers::Array<char>> doConvertDataToData(Magnum::ShaderTools::Stage stage, Containers::ArrayView<const char> data) override;

        struct State;
        Containers::Pointer<State> _state;
};

}}

#endif
